// 参数列表一致，或者参数列表中的参数多的可以兼容少的
class PP {
    new: number
    xxx: number
}

class PP2 {
    new: number
    xxx: number
    // 比PP多一个属性
    zzz: number
}

const p4: PP = new PP2()
p4.new = 23
p4.xxx = 25
console.log(p4)


// 函数之间的兼容性类型
type F1 = (a: number) => void
type F2 = (a: number, b: number) => void
let ff1: F2 = (a: number) => {
    console.log("使用的是F1中的参数", a)
}
ff1(2, 4)


interface Point2D {
    x:number
    y:number
}
interface Point3D {
    x:number
    y:number
    z:number
}
type Fn1 = (p2:Point2D)=>void
type Fn2 = (p2:Point3D)=>void

let fn1:Fn1
let fn2:Fn2

// 参数多的赋值给参数少的，是不行的
// fn1 = fn2
// 参数少的赋值给参数多的，可以
fn2= fn1


// 类型返回值对类型兼容性的影响
type Rf1 = ()=>{x:number}
type Rf2 = ()=>{x:number;y:number}

let rf1:Rf1
let rf2:Rf2

// 根据对象间的类型兼容性，参数多的可以赋值给参数少的
rf1= rf2
// 根据对象间的类型兼容性 参数少的不能赋值给参数多的
// rf2=rf1



